home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / umich / utils / sort.arc / fastcmp.asm next >
Assembly Source File  |  1989-03-30  |  11KB  |  602 lines
  1. ******************************************************************************
  2. *                                                                            *
  3. *   fastcmp.asm version 1.0 of 22 Januari 1989    (C) L.J.M. de Wit 1989     *
  4. *                                                                            *
  5. * This software may be used and distributed freely if not used commercially  *
  6. * and the originator (me) is mentioned in the source (just leave this 9 line *
  7. * header intact).                                                            *
  8. *                                                                            *
  9. ******************************************************************************
  10. *
  11. * fastcmp.asm: fast sort functions
  12. *
  13. *   The code here presented is offered as a replacement for some of the C
  14. *   functions present in sortcomp.c. Since comparisions are done a lot while
  15. *   sorting, some performance tweaking didn't seem misplaced.
  16. *
  17. *   As for documentation, a reference is made to the corresponding C functions
  18. *   in sortcomp.c. Most of the code here does simple work, like swapping
  19. *   arguments (for the 'r' options), and/or skipping white space (for the 'b'
  20. *   options; marked by 'skips' labels).
  21. *
  22.  
  23.    section s.ccode
  24.  
  25. tab   equ   9
  26.  
  27.    xref     c_df
  28.    xref     c_d
  29.    xref     c_if
  30.    xref     c_i
  31.    xref     c_af
  32.  
  33.    xref     c_dfu
  34.    xref     c_du
  35.    xref     c_ifu
  36.    xref     c_iu
  37.    xref     c_afu
  38.  
  39.    xdef     c_dbfr
  40. c_dbfr
  41. * Dict/Blank/Fold/Reverse  *
  42.    move.l   4(sp),a0
  43.    move.l   8(sp),4(sp)
  44.    move.l   a0,8(sp)
  45.    move.l   12(sp),a0
  46.    move.l   16(sp),12(sp)
  47.    move.l   a0,16(sp)
  48. *  FALLTHROUGH
  49.  
  50.    xdef     c_dbf
  51. c_dbf
  52. * Dict/Blank/Fold *
  53.    movea.l  4(sp),a0
  54.    movea.l  8(sp),a1
  55. skips0a
  56.    move.b   (a0)+,d0
  57.    cmp.b    #' ',d0
  58.    beq.s    skips0a
  59.    cmp.b    #tab,d0
  60.    beq.s    skips0a
  61.    subq.l   #1,a0
  62. skips1a
  63.    move.b   (a1)+,d1
  64.    cmp.b    #' ',d1
  65.    beq.s    skips1a
  66.    cmp.b    #tab,d1
  67.    beq.s    skips1a
  68.    subq.l   #1,a1
  69.    move.l   a0,4(sp)
  70.    move.l   a1,8(sp)
  71.    jmp      c_df
  72.  
  73.    xdef     c_dbr
  74. c_dbr
  75. * Dict/Blank/Reverse  *
  76.    move.l   4(sp),a0
  77.    move.l   8(sp),4(sp)
  78.    move.l   a0,8(sp)
  79.    move.l   12(sp),a0
  80.    move.l   16(sp),12(sp)
  81.    move.l   a0,16(sp)
  82. *  FALLTHROUGH
  83.  
  84.    xdef     c_db
  85. c_db
  86. * Dict/Blank *
  87.    movea.l  4(sp),a0
  88.    movea.l  8(sp),a1
  89. skips0b
  90.    move.b   (a0)+,d0
  91.    cmp.b    #' ',d0
  92.    beq.s    skips0b
  93.    cmp.b    #tab,d0
  94.    beq.s    skips0b
  95.    subq.l   #1,a0
  96. skips1b
  97.    move.b   (a1)+,d1
  98.    cmp.b    #' ',d1
  99.    beq.s    skips1b
  100.    cmp.b    #tab,d1
  101.    beq.s    skips1b
  102.    subq.l   #1,a1
  103.    move.l   a0,4(sp)
  104.    move.l   a1,8(sp)
  105.    jmp      c_d
  106.  
  107.    xdef     c_dfr
  108. c_dfr
  109. * Dict/Fold/Reverse  *
  110.    move.l   4(sp),a0
  111.    move.l   8(sp),4(sp)
  112.    move.l   a0,8(sp)
  113.    move.l   12(sp),a0
  114.    move.l   16(sp),12(sp)
  115.    move.l   a0,16(sp)
  116.    jmp      c_df
  117.  
  118.    xdef     c_dr
  119. c_dr
  120. * Dict/Reverse  *
  121.    move.l   4(sp),a0
  122.    move.l   8(sp),4(sp)
  123.    move.l   a0,8(sp)
  124.    move.l   12(sp),a0
  125.    move.l   16(sp),12(sp)
  126.    move.l   a0,16(sp)
  127.    jmp      c_d
  128.  
  129.    xdef     c_ibfr
  130. c_ibfr
  131. * Norm/Blank/Fold/Reverse  *
  132.    move.l   4(sp),a0
  133.    move.l   8(sp),4(sp)
  134.    move.l   a0,8(sp)
  135.    move.l   12(sp),a0
  136.    move.l   16(sp),12(sp)
  137.    move.l   a0,16(sp)
  138. *  FALLTHROUGH
  139.  
  140.    xdef     c_ibf
  141. c_ibf
  142. * Norm/Blank/Fold *
  143.    movea.l  4(sp),a0
  144.    movea.l  8(sp),a1
  145. skips0c
  146.    move.b   (a0)+,d0
  147.    cmp.b    #' ',d0
  148.    beq.s    skips0c
  149.    cmp.b    #tab,d0
  150.    beq.s    skips0c
  151.    subq.l   #1,a0
  152. skips1c
  153.    move.b   (a1)+,d1
  154.    cmp.b    #' ',d1
  155.    beq.s    skips1c
  156.    cmp.b    #tab,d1
  157.    beq.s    skips1c
  158.    subq.l   #1,a1
  159.    move.l   a0,4(sp)
  160.    move.l   a1,8(sp)
  161.    jmp      c_if
  162.  
  163.    xdef     c_ibr
  164. c_ibr
  165. * Norm/Blank/Reverse  *
  166.    move.l   4(sp),a0
  167.    move.l   8(sp),4(sp)
  168.    move.l   a0,8(sp)
  169.    move.l   12(sp),a0
  170.    move.l   16(sp),12(sp)
  171.    move.l   a0,16(sp)
  172. *  FALLTHROUGH
  173.  
  174.    xdef     c_ib
  175. c_ib
  176. * Norm/Blank *
  177.    movea.l  4(sp),a0
  178.    movea.l  8(sp),a1
  179. skips0d
  180.    move.b   (a0)+,d0
  181.    cmp.b    #' ',d0
  182.    beq.s    skips0d
  183.    cmp.b    #tab,d0
  184.    beq.s    skips0d
  185.    subq.l   #1,a0
  186. skips1d
  187.    move.b   (a1)+,d1
  188.    cmp.b    #' ',d1
  189.    beq.s    skips1d
  190.    cmp.b    #tab,d1
  191.    beq.s    skips1d
  192.    subq.l   #1,a1
  193.    move.l   a0,4(sp)
  194.    move.l   a1,8(sp)
  195.    jmp      c_i
  196.  
  197.    xdef     c_ifr
  198. c_ifr
  199. * Norm/Fold/Reverse  *
  200.    move.l   4(sp),a0
  201.    move.l   8(sp),4(sp)
  202.    move.l   a0,8(sp)
  203.    move.l   12(sp),a0
  204.    move.l   16(sp),12(sp)
  205.    move.l   a0,16(sp)
  206.    jmp      c_if
  207.  
  208.    xdef     c_ir
  209. c_ir
  210. * Norm/Reverse  *
  211.    move.l   4(sp),a0
  212.    move.l   8(sp),4(sp)
  213.    move.l   a0,8(sp)
  214.    move.l   12(sp),a0
  215.    move.l   16(sp),12(sp)
  216.    move.l   a0,16(sp)
  217.    jmp      c_i
  218.  
  219.    xdef     c_abfr
  220. c_abfr
  221. * Blank/Fold/Reverse  *
  222.    move.l   4(sp),a0
  223.    move.l   8(sp),4(sp)
  224.    move.l   a0,8(sp)
  225.    move.l   12(sp),a0
  226.    move.l   16(sp),12(sp)
  227.    move.l   a0,16(sp)
  228. *  FALLTHROUGH
  229.  
  230.    xdef     c_abf
  231. c_abf
  232. * Blank/Fold *
  233.    movea.l  4(sp),a0
  234.    movea.l  8(sp),a1
  235. skips0e
  236.    move.b   (a0)+,d0
  237.    cmp.b    #' ',d0
  238.    beq.s    skips0e
  239.    cmp.b    #tab,d0
  240.    beq.s    skips0e
  241.    subq.l   #1,a0
  242. skips1e
  243.    move.b   (a1)+,d1
  244.    cmp.b    #' ',d1
  245.    beq.s    skips1e
  246.    cmp.b    #tab,d1
  247.    beq.s    skips1e
  248.    subq.l   #1,a1
  249.    move.l   a0,4(sp)
  250.    move.l   a1,8(sp)
  251.    jmp      c_af
  252.  
  253.    xdef     c_abr
  254. c_abr
  255. * Blank/Reverse  *
  256.    move.l   4(sp),a0
  257.    move.l   8(sp),4(sp)
  258.    move.l   a0,8(sp)
  259.    move.l   12(sp),a0
  260.    move.l   16(sp),12(sp)
  261.    move.l   a0,16(sp)
  262. *  FALLTHROUGH
  263.  
  264.    xdef     c_ab
  265. c_ab
  266. * Blank *
  267.    movea.l  4(sp),a0
  268.    movea.l  8(sp),a1
  269. skips0f
  270.    move.b   (a0)+,d0
  271.    cmp.b    #' ',d0
  272.    beq.s    skips0f
  273.    cmp.b    #tab,d0
  274.    beq.s    skips0f
  275.    subq.l   #1,a0
  276. skips1f
  277.    move.b   (a1)+,d1
  278.    cmp.b    #' ',d1
  279.    beq.s    skips1f
  280.    cmp.b    #tab,d1
  281.    beq.s    skips1f
  282.    subq.l   #1,a1
  283.    move.l   a0,4(sp)
  284.    move.l   a1,8(sp)
  285.    jmp      c_a
  286.  
  287.    xdef     c_afr
  288. c_afr
  289. * Fold/Reverse  *
  290.    move.l   4(sp),a0
  291.    move.l   8(sp),4(sp)
  292.    move.l   a0,8(sp)
  293.    move.l   12(sp),a0
  294.    move.l   16(sp),12(sp)
  295.    move.l   a0,16(sp)
  296.    jmp      c_af
  297.  
  298.    xdef     c_ar
  299. c_ar
  300. * Reverse  *
  301.    move.l   4(sp),a0
  302.    move.l   8(sp),4(sp)
  303.    move.l   a0,8(sp)
  304.    move.l   12(sp),a0
  305.    move.l   16(sp),12(sp)
  306.    move.l   a0,16(sp)
  307.    jmp      c_a
  308.  
  309.    xdef     c_a
  310. c_a
  311.    move.l   4(sp),d0
  312.    move.l   12(sp),d1
  313.    sub.l    d0,d1
  314.    move.l   d0,a0
  315.    move.l   8(sp),d0
  316.    move.l   16(sp),d2
  317.    sub.l    d0,d2
  318.    move.l   d0,a1
  319.    move.w   d2,d0
  320.    sub.w    d1,d0
  321.    blt.s    c_asmall
  322.    move.w   d1,d2
  323. c_asmall
  324.    dbra     d2,c_aloop
  325. c_aeqs
  326.    ext.l    d0
  327.    rts
  328.  
  329. c_aloop
  330.    cmp.b    (a0)+,(a1)+
  331.    dbne     d2,c_aloop
  332.    beq.s    c_aeqs
  333.    bpl.s    c_aplus
  334.    moveq.l  #1,d0
  335.    rts
  336. c_aplus
  337.    moveq.l  #-1,d0
  338.    rts
  339.  
  340. * Unbounded comparisions start here *
  341.  
  342.    xdef     c_dbfru
  343. c_dbfru
  344. * Dict/Blank/Fold/Reverse  *
  345.    move.l   4(sp),a1
  346.    move.l   8(sp),a0
  347.    bra.s    skips0g
  348.  
  349.    xdef     c_dbfu
  350. c_dbfu
  351. * Dict/Blank/Fold  *
  352.    movea.l  4(sp),a0
  353.    movea.l  8(sp),a1
  354. skips0g
  355.    move.b   (a0)+,d0
  356.    cmp.b    #' ',d0
  357.    beq.s    skips0g
  358.    cmp.b    #tab,d0
  359.    beq.s    skips0g
  360.    subq.l   #1,a0
  361. skips1g
  362.    move.b   (a1)+,d1
  363.    cmp.b    #' ',d1
  364.    beq.s    skips1g
  365.    cmp.b    #tab,d1
  366.    beq.s    skips1g
  367.    subq.l   #1,a1
  368.    move.l   a0,4(sp)
  369.    move.l   a1,8(sp)
  370.    jmp      c_dfu
  371.  
  372.    xdef     c_dbru
  373. c_dbru
  374. * Dict/Blank/Reverse  *
  375.    move.l   4(sp),a1
  376.    move.l   8(sp),a0
  377.    bra.s    skips0h
  378.  
  379.    xdef     c_dbu
  380. c_dbu
  381. * Dict/Blank  *
  382.    movea.l  4(sp),a0
  383.    movea.l  8(sp),a1
  384. skips0h
  385.    move.b   (a0)+,d0
  386.    cmp.b    #' ',d0
  387.    beq.s    skips0h
  388.    cmp.b    #tab,d0
  389.    beq.s    skips0h
  390.    subq.l   #1,a0
  391. skips1h
  392.    move.b   (a1)+,d1
  393.    cmp.b    #' ',d1
  394.    beq.s    skips1h
  395.    cmp.b    #tab,d1
  396.    beq.s    skips1h
  397.    subq.l   #1,a1
  398.    move.l   a0,4(sp)
  399.    move.l   a1,8(sp)
  400.    jmp      c_du
  401.  
  402.    xdef     c_dfru
  403. c_dfru
  404. * Dict/Fold/Reverse  *
  405.    move.l   4(sp),a0
  406.    move.l   8(sp),4(sp)
  407.    move.l   a0,8(sp)
  408.    jmp      c_dfu
  409.  
  410.    xdef     c_dru
  411. c_dru
  412. * Dict/Reverse  *
  413.    move.l   4(sp),a0
  414.    move.l   8(sp),4(sp)
  415.    move.l   a0,8(sp)
  416.    jmp      c_du
  417.  
  418.    xdef     c_ibfru
  419. c_ibfru
  420. * Norm/Blank/Fold/Reverse  *
  421.    move.l   4(sp),a1
  422.    move.l   8(sp),a0
  423.    bra.s    skips0i
  424. *  FALLTHROUGH
  425.  
  426.    xdef     c_ibfu
  427. c_ibfu
  428. * Norm/Blank/Fold  *
  429.    movea.l  4(